/**
 * 用户身份管理服务
 * 提供登录、登出、临时用户管理等功能
 */

import { generateAnonymousUserId } from '@/services/AnonymousUser/api';

/**
 * 生成临时用户ID（前端备用方案）
 */
export const generateTempUserId = (): string => {
  const now = new Date();
  const year = (now.getFullYear() % 100).toString().padStart(2, '0');
  const month = (now.getMonth() + 1).toString().padStart(2, '0');
  const day = now.getDate().toString().padStart(2, '0');
  const hour = now.getHours().toString().padStart(2, '0');
  const minute = now.getMinutes().toString().padStart(2, '0');
  const second = now.getSeconds().toString().padStart(2, '0');
  const random = Math.floor(Math.random() * 900 + 100).toString();
  return `${year}${month}${day}${hour}${minute}${second}${random}`;
};

/**
 * 获取或创建临时用户ID（异步，优先从后端获取）
 */
export const getTempUserId = async (): Promise<string> => {
  let tempId = localStorage.getItem('tempUserId');
  
  // 自动修复：检测并清理错误的值
  if (tempId === '[object Object]' || tempId === 'undefined' || tempId === 'null') {
    console.warn('[用户身份] 检测到错误的tempUserId，自动清理');
    localStorage.removeItem('tempUserId');
    tempId = null;
  }
  
  // 验证是否为有效的15位数字
  if (tempId && (tempId.length !== 15 || !/^\d{15}$/.test(tempId))) {
    console.warn('[用户身份] 检测到无效的tempUserId格式，自动清理');
    localStorage.removeItem('tempUserId');
    tempId = null;
  }
  
  if (tempId) {
    return tempId;
  }

  try {
    // 调用后端API生成临时用户ID
    const response = await generateAnonymousUserId();
    
    // 后端有全局响应包装，从data字段提取ID
    let anonymousUserId;
    if (typeof response === 'object' && response !== null && response.data !== undefined) {
      anonymousUserId = response.data;
    } else {
      anonymousUserId = response;
    }
    
    if (anonymousUserId) {
      tempId = String(anonymousUserId);
      
      // 验证格式
      if (tempId.length === 15 && /^\d{15}$/.test(tempId)) {
        localStorage.setItem('tempUserId', tempId);
        console.log('[用户身份] ✅ 从后端生成临时用户ID成功:', tempId);
        return tempId;
      }
    }
  } catch (error) {
    console.error('从后端生成临时用户ID失败:', error);
  }

  // 后端失败，使用前端生成
  tempId = generateTempUserId();
  localStorage.setItem('tempUserId', tempId);
  console.warn('[用户身份] 后端生成失败，使用前端生成:', tempId);
  return tempId;
};

/**
 * 检查是否为临时用户ID（15位数字）
 */
export const isTempUserId = (userId: string): boolean => {
  return userId.length === 15 && /^\d{15}$/.test(userId);
};

/**
 * 获取当前用户ID（同步方法）
 * 注意：如果需要调用后端生成临时ID，建议使用异步版本 getTempUserIdAsync
 */
export const getCurrentUserId = (): string => {
  try {
    const userInfo = localStorage.getItem('userInfo');
    if (userInfo) {
      const user = JSON.parse(userInfo);
      if (user.id) {
        return user.id.toString();
      }
    }
  } catch (error) {
    console.warn('获取用户信息失败:', error);
  }
  
  // 同步方法只能返回localStorage中的tempUserId
  let tempId = localStorage.getItem('tempUserId');
  if (!tempId) {
    // 如果没有，先用前端生成，后续会被后端生成的覆盖
    tempId = generateTempUserId();
    localStorage.setItem('tempUserId', tempId);
  }
  return tempId;
};

/**
 * 获取当前用户ID（异步版本，推荐）
 */
export const getCurrentUserIdAsync = async (): Promise<string> => {
  try {
    const userInfo = localStorage.getItem('userInfo');
    if (userInfo) {
      const user = JSON.parse(userInfo);
      if (user.id) {
        return user.id.toString();
      }
    }
  } catch (error) {
    console.warn('获取用户信息失败:', error);
  }
  return await getTempUserId();
};

/**
 * 检查用户是否已登录
 */
export const isUserLoggedIn = (): boolean => {
  try {
    const userInfo = localStorage.getItem('userInfo');
    if (userInfo) {
      const user = JSON.parse(userInfo);
      return !!user.id;
    }
  } catch (error) {
    console.warn('检查登录状态失败:', error);
  }
  return false;
};

/**
 * 获取用户信息
 */
export const getUserInfo = (): any | null => {
  try {
    const userInfo = localStorage.getItem('userInfo');
    if (userInfo) {
      return JSON.parse(userInfo);
    }
  } catch (error) {
    console.warn('获取用户信息失败:', error);
  }
  return null;
};

/**
 * 保存登录用户信息
 */
export const saveUserInfo = (userInfo: any): void => {
  try {
    localStorage.setItem('userInfo', JSON.stringify(userInfo));
    localStorage.setItem('account', userInfo.account || userInfo.username);
    // 保存登录用户ID（会覆盖匿名userId）
    localStorage.setItem('userId', userInfo.id.toString());
    // 清除旧的tempUserId字段
    localStorage.removeItem('tempUserId');
    console.log('✅ [登录] 用户信息已保存, userId:', userInfo.id);
  } catch (error) {
    console.error('保存用户信息失败:', error);
  }
};

/**
 * 清除用户信息（登出）
 */
export const clearUserInfo = (): void => {
  localStorage.removeItem('userInfo');
  localStorage.removeItem('account');
  localStorage.removeItem('token');
  localStorage.removeItem('userId');  // 清除userId，下次会重新生成匿名ID
  localStorage.removeItem('tempUserId');  // 兼容旧字段
  console.log('✅ [登出] 用户信息已清除');
};

/**
 * 用户身份服务
 */
export const UserIdentityService = {
  generateTempUserId,
  getTempUserId,
  getCurrentUserId,
  getCurrentUserIdAsync,
  isTempUserId,
  isUserLoggedIn,
  getUserInfo,
  saveUserInfo,
  clearUserInfo,
};

export default UserIdentityService;









